// Go作者版权所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package modload

import (
	"context"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"unicode"

	"cmd/go/internal/base"
	"cmd/go/internal/cfg"
	"cmd/go/internal/fsys"
	"cmd/go/internal/lockedfile"
	"cmd/go/internal/modfetch"
	"cmd/go/internal/par"
	"cmd/go/internal/trace"

	"golang.org/x/mod/modfile"
	"golang.org/x/mod/module"
	"golang.org/x/mod/semver"
)

const (
	// 窄带版本v是Go版本（加上前导“v”），在该版本上
	// 模块“全部”模式不再覆盖
	// 在主模块之外进行测试。
	narrowAllVersionV = "v1.16"

	// lazyLoadingVersionV是Go版本（加上前导的“v”），其中
	// 模块的go.mod文件预计将列出每个模块的明确要求
	// 提供由该模块传递导入的任何包的模块。
	lazyLoadingVersionV = "v1.17"

	// separateIndirectVersionV是Go版本（加上前导的“v”），其
	// "
	// 一个。请参阅https:
	separateIndirectVersionV = "v1.17"
)

const (
	// go117EnableLazyLoading切换是否应设置延迟加载代码路径
	// 忙碌的一旦延迟加载实现稳定，它将被删除
	// 而且经过了很好的测试。
	go117EnableLazyLoading = true

	// go1117LazyTODO是一个常量，它只存在于延迟加载完成之前
	// 执行。它的使用表明，如果
	// 主模块是惰性的。
	go117LazyTODO = false
)

var modFile *modfile.File

// modFileGoVersion返回满足需求的（非空）Go版本
// 如果modFile为nil，则为最新Go版本。
func modFileGoVersion() string {
	if modFile == nil {
		return LatestGoVersion()
	}
	if modFile.Go == nil || modFile.Go.Version == "" {
		// 主模块必须有一个go.mod文件，而该文件缺少
		// “go”指令。“go”命令已添加该指令
		// 自动从Go 1.12开始，因此此模块的日期为Go 1.11或
		// 被错误地手工编辑过。
		// None
		// go.mod文件的语义或多或少与go 1.11相同
		// 通过Go 1.16，在1.17更改为延迟加载。所以即使
		// 没有“go”指令的go.mod文件理论上是go 1.11文件，
		// 脚本可能会假定它最终成为Go 1.16模块。
		return "1.16"
	}
	return modFile.Go.Version
}

// modFileIndex是与modFile相对应的数据索引
// 在特定的时间点。
type modFileIndex struct {
	data            []byte
	dataNeedsFix    bool // 如果fixVersion在分析数据时应用了更改，则为true
	module          module.Version
	goVersionV      string // 前缀为“v”的政府版本
	require         map[module.Version]requireMeta
	replace         map[module.Version]module.Version
	highestReplaced map[string]string // 每个模块路径的最高替换版本；仅用于通配符替换的空字符串
	exclude         map[module.Version]bool
}

// index是go.mod文件上次读取或写入时的索引。
var index *modFileIndex

type requireMeta struct {
	indirect bool
}

// modDepth指示应该为go.mod文件加载哪些依赖项。
type modDepth uint8

const (
	lazy  modDepth = iota // 仅在需要时加载依赖项
	eager                 // 急切地加载所有可传递的依赖项
)

func modDepthFromGoVersion(goVersion string) modDepth {
	if !go117EnableLazyLoading {
		return eager
	}
	if semver.Compare("v"+goVersion, lazyLoadingVersionV) < 0 {
		return eager
	}
	return lazy
}

// CheckAllowed返回一个错误，如果m被
// 主模块的go.mod或由其作者收回。大多数版本查询使用
// 这将筛选出不应使用的版本。
func CheckAllowed(ctx context.Context, m module.Version) error {
	if err := CheckExclusions(ctx, m); err != nil {
		return err
	}
	if err := CheckRetractions(ctx, m); err != nil {
		return err
	}
	return nil
}

// ErrDisallowed由传递给Query和类似查询的版本谓词返回
// 用于指示不应考虑某个版本的函数。
var ErrDisallowed = errors.New("disallowed module version")

// CheckExclutions返回一个错误，如果模块m为
// 被主模块的go.mod文件排除。
func CheckExclusions(ctx context.Context, m module.Version) error {
	if index != nil && index.exclude[m] {
		return module.VersionError(m, errExcluded)
	}
	return nil
}

var errExcluded = &excludedError{}

type excludedError struct{}

func (e *excludedError) Error() string     { return "excluded by go.mod" }
func (e *excludedError) Is(err error) bool { return err == ErrDisallowed }

// CheckRetractions返回一个错误，如果模块m已被
// 它的作者。
func CheckRetractions(ctx context.Context, m module.Version) (err error) {
	defer func() {
		if retractErr := (*ModuleRetractedError)(nil); err == nil || errors.As(err, &retractErr) {
			return
		}
		// 将错误归因于正在检查的版本，而不是来自的版本
		// 要加载的缩回部分。
		if mErr := (*module.ModuleError)(nil); errors.As(err, &mErr) {
			err = mErr.Err
		}
		err = &retractionLoadingError{m: m, err: err}
	}()

	if m.Version == "" {
		// 主模块、标准库或文件替换模块。
		// 不能收回。
		return nil
	}
	if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
		// 该模块的所有版本均已更换。
		// 不要加载回缩，因为我们只加载替换件。
		return nil
	}

	// 找到模块的最新可用版本，并加载其go.mod。如果
	// 最新版本已被替换，我们将加载替换版本。
	// None
	// 如果加载go.mod时出错，我们将在此处返回它。这些错误
	// 通常应被呼叫者忽略，因为在
	// 我们离线了。这些错误并不等同于ErrDisallowed，因此
	// 可能与回缩错误不同。
	// None
	// 我们在这里加载原始文件：go.mod文件可能有不同的模块
	// 如果模块或其存储库被重命名，我们期望的路径。
	// 我们仍然希望将收回应用于模块的其他别名。
	rm, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
	if err != nil {
		return err
	}
	summary, err := rawGoModSummary(rm)
	if err != nil {
		return err
	}

	var rationale []string
	isRetracted := false
	for _, r := range summary.retract {
		if semver.Compare(r.Low, m.Version) <= 0 && semver.Compare(m.Version, r.High) <= 0 {
			isRetracted = true
			if r.Rationale != "" {
				rationale = append(rationale, r.Rationale)
			}
		}
	}
	if isRetracted {
		return module.VersionError(m, &ModuleRetractedError{Rationale: rationale})
	}
	return nil
}

type ModuleRetractedError struct {
	Rationale []string
}

func (e *ModuleRetractedError) Error() string {
	msg := "retracted by module author"
	if len(e.Rationale) > 0 {
		// 这是一个打印在终端上的短错误，所以
		// 打印第一个理由。
		msg += ": " + ShortMessage(e.Rationale[0], "retracted by module author")
	}
	return msg
}

func (e *ModuleRetractedError) Is(err error) bool {
	return err == ErrDisallowed
}

type retractionLoadingError struct {
	m   module.Version
	err error
}

func (e *retractionLoadingError) Error() string {
	return fmt.Sprintf("loading module retractions for %v: %v", e.m, e.err)
}

func (e *retractionLoadingError) Unwrap() error {
	return e.err
}

// ShortMessage从go.mod返回字符串（例如，收回
// 基本原理或弃用信息），可在终端中安全打印。
// None
// 如果给定的字符串为空，ShortMessage将返回给定的默认值。如果
// 给定字符串太长或包含不可打印字符，短消息
// 返回硬编码字符串。
func ShortMessage(message, emptyDefault string) string {
	const maxLen = 500
	if i := strings.Index(message, "\n"); i >= 0 {
		message = message[:i]
	}
	message = strings.TrimSpace(message)
	if message == "" {
		return emptyDefault
	}
	if len(message) > maxLen {
		return "(message omitted: too long)"
	}
	for _, r := range message {
		if !unicode.IsGraphic(r) && !unicode.IsSpace(r) {
			return "(message omitted: contains non-printable characters)"
		}
	}
	// 注意：go.mod解析器拒绝无效的UTF-8，所以这里不检查它。
	return message
}

// CheckDeprecation从的go.mod文件返回一条弃用消息
// 给定模块的最新版本。弃用消息是注释
// 在以开头的模块指令之前或在同一行上
// “弃用：”并一直运行到段落末尾。
// None
// 如果无法加载消息，CheckDeprecation将返回错误。
// CheckDeprecation返回“”，如果没有弃用消息，则返回nil。
func CheckDeprecation(ctx context.Context, m module.Version) (deprecation string, err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("loading deprecation for %s: %w", m.Path, err)
		}
	}()

	if m.Version == "" {
		// 主模块、标准库或文件替换模块。
		// 不要看别人的嘲笑。
		return "", nil
	}
	if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
		// 该模块的所有版本均已更换。
		// 我们将分别查找替换项的折旧率。
		return "", nil
	}

	latest, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
	if err != nil {
		return "", err
	}
	summary, err := rawGoModSummary(latest)
	if err != nil {
		return "", err
	}
	return summary.deprecated, nil
}

// Replacement从go.mod返回mod的替换项（如果有）。
// 如果mod没有替换件，则替换件返回
// 一个模块。路径为“”的版本。
func Replacement(mod module.Version) module.Version {
	if index != nil {
		if r, ok := index.replace[mod]; ok {
			return r
		}
		if r, ok := index.replace[module.Version{Path: mod.Path}]; ok {
			return r
		}
	}
	return module.Version{}
}

// resolveReplacement返回实际用于加载源代码的模块
// 对于m：要么是m本身，要么是m的替换（如果m被替换）。
func resolveReplacement(m module.Version) module.Version {
	if r := Replacement(m); r.Path != "" {
		return r
	}
	return m
}

// indexModFile重建modFile的索引。
// 如果modFile在第一次读取后已被更改，
// 必须在indexModFile之前调用modFile.Cleanup。
func indexModFile(data []byte, modFile *modfile.File, needsFix bool) *modFileIndex {
	i := new(modFileIndex)
	i.data = data
	i.dataNeedsFix = needsFix

	i.module = module.Version{}
	if modFile.Module != nil {
		i.module = modFile.Module.Mod
	}

	i.goVersionV = ""
	if modFile.Go == nil {
		rawGoVersion.Store(Target, "")
	} else {
		// 我们将使用semver包来比较Go版本，所以请继续
		// 并添加它期望的“v”前缀一次，而不是每次。
		i.goVersionV = "v" + modFile.Go.Version
		rawGoVersion.Store(Target, modFile.Go.Version)
	}

	i.require = make(map[module.Version]requireMeta, len(modFile.Require))
	for _, r := range modFile.Require {
		i.require[r.Mod] = requireMeta{indirect: r.Indirect}
	}

	i.replace = make(map[module.Version]module.Version, len(modFile.Replace))
	for _, r := range modFile.Replace {
		if prev, dup := i.replace[r.Old]; dup && prev != r.New {
			base.Fatalf("go: conflicting replacements for %v:\n\t%v\n\t%v", r.Old, prev, r.New)
		}
		i.replace[r.Old] = r.New
	}

	i.highestReplaced = make(map[string]string)
	for _, r := range modFile.Replace {
		v, ok := i.highestReplaced[r.Old.Path]
		if !ok || semver.Compare(r.Old.Version, v) > 0 {
			i.highestReplaced[r.Old.Path] = r.Old.Version
		}
	}

	i.exclude = make(map[module.Version]bool, len(modFile.Exclude))
	for _, x := range modFile.Exclude {
		i.exclude[x.Mod] = true
	}

	return i
}

// modFileIsDirty报告go.mod文件的差异是否有意义
// 根据索引的内容。
// 如果modFile在第一次读取后已被更改（甚至是经过修饰），
// None
func (i *modFileIndex) modFileIsDirty(modFile *modfile.File) bool {
	if i == nil {
		return modFile != nil
	}

	if i.dataNeedsFix {
		return true
	}

	if modFile.Module == nil {
		if i.module != (module.Version{}) {
			return true
		}
	} else if modFile.Module.Mod != i.module {
		return true
	}

	if modFile.Go == nil {
		if i.goVersionV != "" {
			return true
		}
	} else if "v"+modFile.Go.Version != i.goVersionV {
		if i.goVersionV == "" && cfg.BuildMod != "mod" {
			// go.mod文件并不总是需要“go”版本，所以不要出错
			// 如果缺少一个模块-我们可能位于模块中较旧的模块内
			// 缓存，并且应该偏向于提供有用的行为。
		} else {
			return true
		}
	}

	if len(modFile.Require) != len(i.require) ||
		len(modFile.Replace) != len(i.replace) ||
		len(modFile.Exclude) != len(i.exclude) {
		return true
	}

	for _, r := range modFile.Require {
		if meta, ok := i.require[r.Mod]; !ok {
			return true
		} else if r.Indirect != meta.indirect {
			if cfg.BuildMod == "readonly" {
				// 模块要求一致；只有“
				// 错误的评论。但这些数据只能保证是准确的
				// 在“整理一下”之后——最好在之前运行一下
				// 提交更改，但它肯定不是强制性的。
			} else {
				return true
			}
		}
	}

	for _, r := range modFile.Replace {
		if r.New != i.replace[r.Old] {
			return true
		}
	}

	for _, x := range modFile.Exclude {
		if !i.exclude[x.Mod] {
			return true
		}
	}

	return false
}

// rawGoVersion记录从每个模块的Go.mod文件解析的Go版本。
// None
// 如果更换了模块，则更换的版本由
// 更换模块。版本，而不是要更换的版本。
var rawGoVersion sync.Map // 映射[module.Version]字符串

// modFileSummary是一个go.mod文件的摘要，我们不需要对它进行修改
// 保留完整信息-例如，依赖项的go.mod文件
// 单元
type modFileSummary struct {
	module     module.Version
	goVersion  string
	depth      modDepth
	require    []module.Version
	retract    []retraction
	deprecated string
}

// 收回包括收回版本间隔和基本原理。
// retraction类似于modfile.Retract，但它不指向语法树。
type retraction struct {
	modfile.VersionInterval
	Rationale string
}

// goModSummary返回模块m的go.mod文件的摘要，
// 考虑到m的任何替代品，排除其依赖性，
// 和/或自动售货机。
// None
// m必须是模块图中的版本，可以从目标模块访问。
// 在只读模式下，go.sum文件必须包含m的go.mod文件的条目
// （或其替代品）。不能为目标模块调用goModSummary
// 自身，因为其要求可能会发生变化。将rawGoModSummary用于其他
// 模块版本。
// None
// 调用者不得修改返回的摘要。
func goModSummary(m module.Version) (*modFileSummary, error) {
	if m == Target {
		panic("internal error: goModSummary called on the Target module")
	}

	if cfg.BuildMod == "vendor" {
		summary := &modFileSummary{
			module: module.Version{Path: m.Path},
		}
		if vendorVersion[m.Path] != m.Version {
			// 此模块不是供应商，因此无法从中加载包，并且
			// 它不能与生成相关。
			return summary, nil
		}

		// 对于目标以外的每个模块，
		// 从modules.txt返回模块的完整列表。
		readVendorList()

		// 我们不知道卖方模块实际依赖什么版本，
		// 所以假设它需要一切。
		summary.require = vendorList
		return summary, nil
	}

	actual := resolveReplacement(m)
	if HasModRoot() && cfg.BuildMod == "readonly" && actual.Version != "" {
		key := module.Version{Path: actual.Path, Version: actual.Version + "/go.mod"}
		if !modfetch.HaveSum(key) {
			suggestion := fmt.Sprintf("; to add it:\n\tgo mod download %s", m.Path)
			return nil, module.VersionError(actual, &sumMissingError{suggestion: suggestion})
		}
	}
	summary, err := rawGoModSummary(actual)
	if err != nil {
		return nil, err
	}

	if actual.Version == "" {
		// 实际的模块是一个文件系统本地替换，对此我们有
		// 不幸的是，没有对模块行或
		// 匹配模块路径。什么都可以。
		// None
		// TODO（bcmills）：删除此特殊情况，更新测试，并添加
		// 发行说明。
	} else {
		if summary.module.Path == "" {
			return nil, module.VersionError(actual, errors.New("parsing go.mod: missing module line"))
		}

		// 理论上，如果
		// 我们获取的版本缺少一个显式的go.mod文件：如果go.mod文件
		// 是显式的，则它应该完全匹配（以确保其他
		// 模块内的包被正确解释）。不幸的是，我们
		// 无法从模块代理协议确定该信息：我们将
		// 将验证留给从
		// 单元
		if mpath := summary.module.Path; mpath != m.Path && mpath != actual.Path {
			return nil, module.VersionError(actual, fmt.Errorf(`parsing go.mod:
	module declares its path as: %s
	        but was required as: %s`, mpath, m.Path))
		}
	}

	if index != nil && len(index.exclude) > 0 {
		// 删除排除版本上的任何要求。
		// 但不要修改缓存的摘要，因为我们可能需要原始摘要
		// 单独总结。
		haveExcludedReqs := false
		for _, r := range summary.require {
			if index.exclude[r] {
				haveExcludedReqs = true
				break
			}
		}
		if haveExcludedReqs {
			s := new(modFileSummary)
			*s = *summary
			s.require = make([]module.Version, 0, len(summary.require))
			for _, r := range summary.require {
				if !index.exclude[r] {
					s.require = append(s.require, r)
				}
			}
			summary = s
		}
	}
	return summary, nil
}

// rawGoModSummary返回模块m的go.mod文件的新摘要，
// 忽略可能适用于m的所有替换，并排除可能适用于m的替换
// 它的依赖性。
// None
// 无法在目标模块上使用rawGoModSummary。
func rawGoModSummary(m module.Version) (*modFileSummary, error) {
	if m == Target {
		panic("internal error: rawGoModSummary called on the Target module")
	}

	type cached struct {
		summary *modFileSummary
		err     error
	}
	c := rawGoModSummaryCache.Do(m, func() interface{} {
		summary := new(modFileSummary)
		name, data, err := rawGoModData(m)
		if err != nil {
			return cached{nil, err}
		}
		f, err := modfile.ParseLax(name, data, nil)
		if err != nil {
			return cached{nil, module.VersionError(m, fmt.Errorf("parsing %s: %v", base.ShortPath(name), err))}
		}
		if f.Module != nil {
			summary.module = f.Module.Mod
			summary.deprecated = f.Module.Deprecated
		}
		if f.Go != nil && f.Go.Version != "" {
			rawGoVersion.LoadOrStore(m, f.Go.Version)
			summary.goVersion = f.Go.Version
			summary.depth = modDepthFromGoVersion(f.Go.Version)
		} else {
			summary.depth = eager
		}
		if len(f.Require) > 0 {
			summary.require = make([]module.Version, 0, len(f.Require))
			for _, req := range f.Require {
				summary.require = append(summary.require, req.Mod)
			}
		}
		if len(f.Retract) > 0 {
			summary.retract = make([]retraction, 0, len(f.Retract))
			for _, ret := range f.Retract {
				summary.retract = append(summary.retract, retraction{
					VersionInterval: ret.VersionInterval,
					Rationale:       ret.Rationale,
				})
			}
		}

		return cached{summary, nil}
	}).(cached)

	return c.summary, c.err
}

var rawGoModSummaryCache par.Cache // 模块版本→ 罗戈莫德总结结果

// rawGoModData返回模块m的go.mod文件的内容，忽略
// 适用于m的所有替代品。
// None
// 无法在目标模块上使用rawGoModData。
// None
// 与rawGoModSummary不同，rawGoModData不会将其结果缓存在内存中。
// 除非您特别需要这些字节，否则请改用rawGoModSummary。
func rawGoModData(m module.Version) (name string, data []byte, err error) {
	if m.Version == "" {
		// m是仅具有文件路径的替换模块。
		dir := m.Path
		if !filepath.IsAbs(dir) {
			dir = filepath.Join(ModRoot(), dir)
		}
		name = filepath.Join(dir, "go.mod")
		if gomodActual, ok := fsys.OverlayPath(name); ok {
			// 如果go.mod是覆盖的一部分，请不要锁定它。
			// 在计划9中，锁定需要chmod，我们不想修改任何文件
			// 在覆盖层中。见#44700。
			data, err = os.ReadFile(gomodActual)
		} else {
			data, err = lockedfile.Read(gomodActual)
		}
		if err != nil {
			return "", nil, module.VersionError(m, fmt.Errorf("reading %s: %v", base.ShortPath(name), err))
		}
	} else {
		if !semver.IsValid(m.Version) {
			// 不允许fetch.Lookup支持的范围更广的查询。
			base.Fatalf("go: internal error: %s@%s: unexpected invalid semantic version", m.Path, m.Version)
		}
		name = "go.mod"
		data, err = modfetch.GoMod(m.Path, m.Version)
	}
	return name, data, err
}

// QueryLastVersionIgnoringRetractions查找最新版本的
// 具有给定路径且不考虑收回或排除的模块
// 版本。
// None
// 如果更换了模块的所有版本，
// QueryLastVersionIgnoringRetractions返回替换，而不进行
// 询问。
// None
// 如果替换了查询到的最新版本，
// QueryLastVersionIgnoringRetractions返回替换。
func queryLatestVersionIgnoringRetractions(ctx context.Context, path string) (latest module.Version, err error) {
	type entry struct {
		latest module.Version
		err    error
	}
	e := latestVersionIgnoringRetractionsCache.Do(path, func() interface{} {
		ctx, span := trace.StartSpan(ctx, "queryLatestVersionIgnoringRetractions "+path)
		defer span.Done()

		if repl := Replacement(module.Version{Path: path}); repl.Path != "" {
			// 该模块的所有版本均已更换。
			// 不需要查询。
			return &entry{latest: repl}
		}

		// 查找模块的最新版本。
		// 忽略主模块go.mod中的排除项。
		const ignoreSelected = ""
		var allowAll AllowedFunc
		rev, err := Query(ctx, path, "latest", ignoreSelected, allowAll)
		if err != nil {
			return &entry{err: err}
		}
		latest := module.Version{Path: path, Version: rev.Version}
		if repl := resolveReplacement(latest); repl.Path != "" {
			latest = repl
		}
		return &entry{latest: latest}
	}).(*entry)
	return e.latest, e.err
}

var latestVersionIgnoringRetractionsCache par.Cache // 路径→ QuerylatesVersionIgnoringRetractions结果
